﻿#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
#include<string>
#include<vector>
using namespace std;
//请你来实现一个 myAtoi(string s) 函数，使其能将字符串转换成一个 32 位有符号整数（类似 C / C++ 中的 atoi 函数）。
//
//函数 myAtoi(string s) 的算法如下： 函数 myAtoi(string s) 的算法如下：
//
//读入字符串并丢弃无用的前导空格
//检查下一个字符（假设还未到字符末尾）为正还是负号，读取该字符（如果有）。 确定最终结果是负数还是正数。 如果两者都不存在，则假定结果为正。
//读入下一个字符，直到到达下一个非数字字符或到达输入的结尾。字符串的其余部分将被忽略。
//将前面步骤读入的这些数字转换为整数（即，"123" -> 123， "0032" -> 32）。如果没有读入数字，则整数为 0 。必要时更改符号（从步骤 2 开始）。
//如果整数数超过 32 位有符号整数范围[−231, 231 − 1] ，需要截断这个整数，使其保持在这个范围内。具体来说，小于 −231 的整数应该被固定为 −231 ，大于 231 − 1 的整数应该被固定为 231 − 1 。
//返回整数作为最终结果。
//
//注意：
//
//本题中的空白字符只包括空格字符 ' ' 。
//本题中的空白字符只包括空格字符 ' ' 。
//除前导空格或数字后的其余字符串外，请勿忽略 任何其他字符。



//class Solution {
//public:
//    bool IsDigit(const char& ch)
//    {
//        if (ch >= '0' && ch <= '9')
//            return true;
//        else
//            return false;
//    }
//    int myAtoi(string str)
//    {
//        int flag = 1, i = 0;
//        long long ret = 0;
//        while (str[i] == ' ')
//        {
//            i++;
//        }
//        if (str[i] == '+' || str[i] == '-')
//        {
//            if (str[i] == '-')
//                flag = -1;
//            i++;
//        }
//        while (i < str.size() && IsDigit(str[i]))
//        {
//            ret = ret * 10 + str[i] - '0';
//            if (ret >= INT_MAX && flag == 1)
//                return INT_MAX;
//            if (ret > INT_MAX && flag == -1)
//                return INT_MIN;
//            i++;
//        }
//        return ret * flag;
//    }
//};
//



//给定两个字符串形式的非负整数 num1 和num2 ，计算它们的和并同样以字符串形式返回。
//
//你不能使用任何內建的用于处理大整数的库（比如 BigInteger）， 也不能直接将输入的字符串转换为整数形式。
//
//
//
//示例 1： 示例 1.
//
//输入：num1 = "11", num2 = "123"
//输出："134"
//
//示例 2： 示例 2.
//
//输入：num1 = "456", num2 = "77"
//输出："533"
//
//示例 3： 示例 3.
//
//输入：num1 = "0", num2 = "0"
//输出："0"
//
//
//
//提示：
//
//1 <= num1.length, num2.length <= 104
//num1 和num2 都只包含数字 0 - 9 num1 和num2 都只包含数字 0 - 9
//num1 和num2 都不包含任何前导零 num1 和num2 都不包含任何前导零
//


//class Solution {
//public:
//    string addStrings(string num1, string num2)
//    {
//        int end1 = num1.size() - 1;
//        int end2 = num2.size() - 1;
//        int next = 0;
//        string s;
//        while (end1 >= 0 || end2 >= 0)
//        {
//            int val1 = end1 >= 0 ? num1[end1--] - '0' : 0;
//            int val2 = end2 >= 0 ? num2[end2--] - '0' : 0;
//            int ret = val1 + val2 + next;
//            next = ret / 10;
//            ret = ret % 10;
//            // //尾插，时间复杂度为O（N）
//            // s.push_back(ret + '0');
//
//
//            //头插，但时间复杂度为O（N^2）
//            s.insert(s.begin(), 1, ret + '0');
//
//        }
//        if (next == 1)
//        {
//            // //尾插
//            // s.push_back('1');
//
//
//            //头插
//            s.insert(s.begin(), 1, '1');
//
//
//        }
//
//        //reverse(s.begin(),s.end());
//        return s;
//
//
//
//    }
//};



//编写一个函数，其作用是将输入的字符串反转过来。输入字符串以字符数组 s 的形式给出。
//
//不要给另外的数组分配额外的空间，你必须原地修改输入数组、使用 O(1) 的额外空间解决这一问题。
//
//
//
//示例 1： 示例 1.
//
//输入：s = ["h", "e", "l", "l", "o"]
//输出：["o", "l", "l", "e", "h"]
//
//示例 2： 示例 2.
//
//输入：s = ["H", "a", "n", "n", "a", "h"]
//输出：["h", "a", "n", "n", "a", "H"]
//
//
//
//提示：
//
//1 <= s.length <= 105
//s[i] 都是 ASCII 码表中的可打印字符
// 
// 



//class Solution {
//public:
//    void reverseString(vector<char>& s)
//    {
//        int end = s.size() - 1;
//        int begin = 0;
//        while (begin < end)
//        {
//            char ch = s[end];
//            s[end] = s[begin];
//            s[begin] = ch;
//            end--;
//            begin++;
//        }
//    }
//};



//计算字符串最后一个单词的长度，单词以空格隔开，字符串长度小于5000。（注：字符串末尾不以空格为结尾）
//输入描述：
//
//输入一行，代表要计算的字符串，非空，长度小于5000。
//输出描述：
//
//输出一个整数，表示输入字符串最后一个单词的长度。
// 





//#include <iostream>  
//#include <string>  
//
//using namespace std;
//
//int main() {
//    string str;
//    getline(std::cin, str);
//    int end = str.size() - 1;
//
//    int start = end;
//    while (start >= 0 && str[start] != ' ')
//    {
//        --start;
//    }
//    cout << end - start << endl;
//
//    return 0;
//}
// 
// 




//如果在将所有大写字符转换为小写字符、并移除所有非字母数字字符之后，短语正着读和反着读都一样。则可以认为该短语是一个 回文串 。
//
//字母和数字都属于字母数字字符。 字母和数字都属于字母数字字符。
//
//给你一个字符串 s，如果它是 回文串 ，返回 true ；否则，返回 false 。
// 
// 
// 


// class Solution {
// public:
//     bool isPalindrome(std::string s) {  
//        string filtered;  
//         // 遍历输入字符串，过滤并转换为小写  
//         for (char c : s) {  
//             if (isalnum(c)) 
//             {  
//                 filtered += tolower(c);  
//             }  
//         }  
//         // 使用双指针法检查回文  
//         int left = 0;  
//         int right = filtered.size() - 1;  
//         while (left < right) {  
//             if (filtered[left] != filtered[right]) {  
//                 return false;  
//             }  
//             left++;  
//             right--;  
//         }  

//         return true;  
//     }  
// };
//class Solution {
//public:
//    bool IsLetterDigit(const char& ch)
//    {
//        if ((ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z') || (ch >= '0' && ch <= '9'))
//            return true;
//        else
//            return false;
//    }
//    bool isPalindrome(string s)
//    {
//        if (s.size() == 1)
//            return true;
//        string::iterator it = s.begin();
//        while (it != s.end())
//        {
//            if (!IsLetterDigit(*it))
//                s.erase(it);
//            else
//                it++;
//        }
//        transform(s.begin(), s.end(), s.begin(), [](char ch) {return tolower(ch); });
//        int begin = 0;
//        int end = s.size() - 1;
//        while (begin < end)
//        {
//            if (s[begin] != s[end])
//                return false;
//            end--;
//            begin++;
//        }
//        return true;
//    }
//};
// 
// 



//给定一个字符串 s 和一个整数 k，从字符串开头算起，每计数至 2k 个字符，就反转这 2k 字符中的前 k 个字符。
//
//如果剩余字符少于 k 个，则将剩余字符全部反转。
//如果剩余字符小于 2k 但大于或等于 k 个，则反转前 k 个字符，其余字符保持原样。



//给定一个字符串 s ，你需要反转字符串中每个单词的字符顺序，同时仍保留空格和单词的初始顺序。
//
//
//
//示例 1： 示例 1.
//
//输入：s = "Let's take LeetCode contest"
//输出："s'teL ekat edoCteeL tsetnoc"
//
//示例 2: 示例 2.
//
//输入： s = "Mr Ding"
//输出："rM gniD"



//class Solution {
//public:
//    string reverseWords(string s)
//    {
//        if (s.size() == 1)
//            return s;
//        string::iterator it = s.begin();
//        while (it != s.end())
//        {
//            string::iterator prev = it;
//            while (it != s.end() && *it != ' ')
//            {
//                it++;
//            }
//            reverse(prev, it);
//            //注意当it指向最后一个单词字母的下一个位置时(it= end())要退出循环
//            //否则后面的it++会越界访问
//            if (it == s.end())
//                break;
//            it++;
//        }
//        return s;
//    }
//};
///////////////////////////////////////////////////////////////////////////////
//请你来实现一个 myAtoi(string s) 函数，使其能将字符串转换成一个 32 位有符号整数（类似 C / C++ 中的 atoi 函数）。
//
//函数 myAtoi(string s) 的算法如下： 函数 myAtoi(string s) 的算法如下：
//
//读入字符串并丢弃无用的前导空格
//检查下一个字符（假设还未到字符末尾）为正还是负号，读取该字符（如果有）。 确定最终结果是负数还是正数。 如果两者都不存在，则假定结果为正。
//读入下一个字符，直到到达下一个非数字字符或到达输入的结尾。字符串的其余部分将被忽略。
//将前面步骤读入的这些数字转换为整数（即，"123" -> 123， "0032" -> 32）。如果没有读入数字，则整数为 0 。必要时更改符号（从步骤 2 开始）。
//如果整数数超过 32 位有符号整数范围[−231, 231 − 1] ，需要截断这个整数，使其保持在这个范围内。具体来说，小于 −231 的整数应该被固定为 −231 ，大于 231 − 1 的整数应该被固定为 231 − 1 。
//返回整数作为最终结果。
//
//注意：
//
//本题中的空白字符只包括空格字符 ' ' 。
//本题中的空白字符只包括空格字符 ' ' 。
//除前导空格或数字后的其余字符串外，请勿忽略 任何其他字符。

//class Solution {
//public:
//    bool isdigit(const char& ch)
//    {
//        if (ch >= '0' && ch <= '9')
//            return true;
//        else
//            return false;
//    }
//    int myAtoi(string str)
//    {
//        if (str.size() == 0)
//            return 0;
//        string::iterator it = str.begin();
//        int flag = 1;
//        long long ret = 0;
//        while (it < str.end() && *it == ' ')
//        {
//            it++;
//        }
//        if (*it == '+' || *it == '-')
//        {
//            if (*it == '-')
//                flag = -1;
//            it++;
//        }
//        while (it < str.end() && isdigit(*it))
//        {
//            ret = ret * 10 + *it - '0';
//            if (ret >= INT_MAX && flag == 1)
//                return INT_MAX;
//            if (ret > INT_MAX && flag == -1)
//                return INT_MIN;
//
//            it++;
//        }
//        return ret * flag;
//
//    }
//};



int main()
{
 
 
	return 0;
}



